/**
 * 主应用模块 - 重构版本
 * 使用新的日志系统和模块化结构
 */

// 创建应用主日志器
const appLogger = window.logger ? window.logger.createContextLogger('App') : console;

/**
 * 应用主类
 */
class App {
    constructor() {
        this.envConfig = window.envConfig;
        this.networkManager = window.networkManager;
        this.dataMigrationManager = window.dataMigrationManager;
        this.api = window.api;
        
        this.isInitialized = false;
        this.currentView = 'dashboard';
        
        appLogger.info('应用实例已创建');
    }
    
    /**
     * 初始化应用
     */
    async initialize() {
        try {
            appLogger.info('开始初始化应用');
            
            // 初始化网络管理器
            await this._initNetworkManager();
            
            // 初始化数据迁移管理器
            await this._initMigrationManager();
            
            // 初始化UI组件
            this._initUI();
            
            // 初始化事件监听器
            this._initializeEventListeners();
            
            // 初始化数据
            await this._initializeData();
            
            // 检查并执行数据迁移
            await this._checkAndPerformMigration();
            
            // 初始化路由
            this._initializeRouting();
            
            this.isInitialized = true;
            appLogger.info('应用初始化完成');
            
            // 显示欢迎信息
            if (this.envConfig && this.envConfig.isDevelopment()) {
                this._showDevelopmentInfo();
            }
        } catch (error) {
            appLogger.error('应用初始化失败:', error);
            this._showError('应用初始化失败，请刷新页面重试');
        }
    }
    
    /**
     * 初始化UI组件
     * @private
     */
    _initializeUI() {
        appLogger.debug('初始化UI组件');
        
        // 初始化导航
        this._initializeNavigation();
        
        // 初始化页面容器
        this._initializePageContainer();
        
        // 初始化通知系统
        this._initializeNotificationSystem();
        
        // 初始化加载指示器
        this._initializeLoadingIndicator();
    }
    
    /**
     * 初始化导航
     * @private
     */
    _initializeNavigation() {
        const navItems = document.querySelectorAll('.nav-item');
        navItems.forEach(item => {
            item.addEventListener('click', (e) => {
                e.preventDefault();
                const view = item.getAttribute('data-view');
                this.navigateToView(view);
            });
        });
    }
    
    /**
     * 初始化页面容器
     * @private
     */
    _initializePageContainer() {
        this.pageContainer = document.getElementById('page-container');
        if (!this.pageContainer) {
            appLogger.warn('页面容器未找到');
        }
    }
    
    /**
     * 初始化通知系统
     * @private
     */
    _initializeNotificationSystem() {
        // 创建通知容器
        if (!document.getElementById('notification-container')) {
            const notificationContainer = document.createElement('div');
            notificationContainer.id = 'notification-container';
            notificationContainer.className = 'notification-container';
            document.body.appendChild(notificationContainer);
        }
        
        // 设置全局通知函数
        window.showNotification = (message, type = 'info', duration = 3000) => {
            this._showNotification(message, type, duration);
        };
    }
    
    /**
     * 初始化加载指示器
     * @private
     */
    _initializeLoadingIndicator() {
        // 创建加载指示器
        if (!document.getElementById('loading-indicator')) {
            const loadingIndicator = document.createElement('div');
            loadingIndicator.id = 'loading-indicator';
            loadingIndicator.className = 'loading-indicator';
            loadingIndicator.innerHTML = '<div class="spinner"></div>';
            document.body.appendChild(loadingIndicator);
        }
    }
    
    /**
     * 初始化事件监听器
     * @private
     */
    _initializeEventListeners() {
        appLogger.debug('初始化事件监听器');
        
        // 网络状态监听器
        if (this.networkManager) {
            this.networkManager.addListener((event, data) => {
                if (event === 'online') {
                    this._showNotification('网络连接已恢复', 'success');
                } else if (event === 'offline') {
                    this._showNotification('网络连接已断开', 'warning');
                }
            });
        }
        
        // 窗口大小变化监听器
        window.addEventListener('resize', () => {
            this._handleResize();
        });
        
        // 键盘快捷键监听器
        document.addEventListener('keydown', (e) => {
            this._handleKeyboardShortcut(e);
        });
    }
    
    /**
     * 初始化数据
     * @private
     */
    async _initializeData() {
        appLogger.debug('初始化数据');
        
        try {
            // 检查API可用性
            const isApiAvailable = await this._checkApiAvailability();
            
            if (isApiAvailable) {
                // 从API加载数据
                await this._loadDataFromAPI();
            } else {
                // 从localStorage加载数据
                this._loadDataFromLocalStorage();
                this._showNotification('API不可用，使用本地数据', 'warning');
            }
        } catch (error) {
            appLogger.error('数据初始化失败:', error);
            this._loadDataFromLocalStorage();
            this._showNotification('数据加载失败，使用本地缓存', 'warning');
        }
    }
    
    /**
     * 检查API可用性
     * @private
     * @returns {Promise<boolean>} API是否可用
     */
    async _checkApiAvailability() {
        try {
            if (this.api && this.api.checkAPIHealth) {
                return await this.api.checkAPIHealth();
            }
            return false;
        } catch (error) {
            appLogger.error('API可用性检查失败:', error);
            return false;
        }
    }
    
    /**
     * 从API加载数据
     * @private
     */
    async _loadDataFromAPI() {
        try {
            const [tasks, notes, settings] = await Promise.all([
                this.api.getTasks(),
                this.api.getNotes(),
                this.api.getSettings()
            ]);
            
            // 保存到localStorage作为缓存
            localStorage.setItem('tasks', JSON.stringify(tasks));
            localStorage.setItem('notes', JSON.stringify(notes));
            localStorage.setItem('settings', JSON.stringify(settings));
            
            appLogger.info('从API加载数据成功');
        } catch (error) {
            appLogger.error('从API加载数据失败:', error);
            throw error;
        }
    }
    
    /**
     * 从localStorage加载数据
     * @private
     */
    _loadDataFromLocalStorage() {
        try {
            const tasks = JSON.parse(localStorage.getItem('tasks') || '[]');
            const notes = JSON.parse(localStorage.getItem('notes') || '[]');
            const settings = JSON.parse(localStorage.getItem('settings') || '{}');
            
            appLogger.info('从localStorage加载数据成功');
        } catch (error) {
            appLogger.error('从localStorage加载数据失败:', error);
            
            // 如果加载失败，初始化默认数据
            this._initializeDefaultData();
        }
    }
    
    /**
     * 初始化默认数据
     * @private
     */
    _initializeDefaultData() {
        appLogger.info('初始化默认数据');
        
        const defaultTasks = [
            { id: '1', text: '欢迎使用AI日常管理助手', completed: false, createdAt: new Date().toISOString() },
            { id: '2', text: '点击添加新任务', completed: false, createdAt: new Date().toISOString() }
        ];
        
        const defaultNotes = [
            { id: '1', title: '欢迎使用', content: '这是您的第一条笔记', createdAt: new Date().toISOString() }
        ];
        
        const defaultSettings = {
            theme: 'light',
            language: 'zh-CN',
            notifications: true
        };
        
        localStorage.setItem('tasks', JSON.stringify(defaultTasks));
        localStorage.setItem('notes', JSON.stringify(defaultNotes));
        localStorage.setItem('settings', JSON.stringify(defaultSettings));
    }
    
    /**
     * 检查并执行数据迁移
     * @private
     */
    async _checkAndPerformMigration() {
        if (!this.dataMigrationManager) {
            appLogger.warn('数据迁移管理器不可用');
            return;
        }
        
        try {
            const result = await this.dataMigrationManager.checkAndPerformMigration();
            
            if (result.status === 'success' && result.hasChanges) {
                this._showNotification('数据迁移完成', 'success');
                appLogger.info('数据迁移完成', result);
            } else if (result.status === 'error') {
                this._showNotification('数据迁移失败', 'error');
                appLogger.error('数据迁移失败', result);
            }
        } catch (error) {
            appLogger.error('数据迁移检查失败:', error);
        }
    }
    
    /**
     * 初始化路由
     * @private
     */
    _initializeRouting() {
        appLogger.debug('初始化路由');
        
        // 检查当前URL并导航到相应视图
        const path = window.location.hash.substring(1) || 'dashboard';
        this.navigateToView(path);
        
        // 监听hash变化
        window.addEventListener('hashchange', () => {
            const path = window.location.hash.substring(1) || 'dashboard';
            this.navigateToView(path);
        });
    }
    
    /**
     * 导航到指定视图
     * @param {string} view - 视图名称
     */
    navigateToView(view) {
        if (this.currentView === view) {
            return;
        }
        
        appLogger.debug(`导航到视图: ${view}`);
        
        // 更新当前视图
        this.currentView = view;
        
        // 更新URL hash
        window.location.hash = view;
        
        // 更新导航状态
        this._updateNavigationState(view);
        
        // 加载视图内容
        this._loadView(view);
    }
    
    /**
     * 更新导航状态
     * @private
     * @param {string} view - 视图名称
     */
    _updateNavigationState(view) {
        const navItems = document.querySelectorAll('.nav-item');
        navItems.forEach(item => {
            if (item.getAttribute('data-view') === view) {
                item.classList.add('active');
            } else {
                item.classList.remove('active');
            }
        });
    }
    
    /**
     * 加载视图内容
     * @private
     * @param {string} view - 视图名称
     */
    _loadView(view) {
        if (!this.pageContainer) {
            appLogger.warn('页面容器不可用');
            return;
        }
        
        // 显示加载指示器
        this._showLoadingIndicator();
        
        // 根据视图名称加载相应内容
        switch (view) {
            case 'dashboard':
                this._loadDashboardView();
                break;
            case 'tasks':
                this._loadTasksView();
                break;
            case 'notes':
                this._loadNotesView();
                break;
            case 'settings':
                this._loadSettingsView();
                break;
            default:
                this._loadNotFoundView();
                break;
        }
        
        // 隐藏加载指示器
        this._hideLoadingIndicator();
    }
    
    /**
     * 加载仪表板视图
     * @private
     */
    _loadDashboardView() {
        appLogger.debug('加载仪表板视图');
        
        // 这里可以加载仪表板内容
        this.pageContainer.innerHTML = `
            <div class="dashboard">
                <h1>仪表板</h1>
                <div class="dashboard-content">
                    <div class="summary-card">
                        <h3>任务</h3>
                        <div class="summary-count" id="task-count">0</div>
                    </div>
                    <div class="summary-card">
                        <h3>笔记</h3>
                        <div class="summary-count" id="note-count">0</div>
                    </div>
                </div>
            </div>
        `;
        
        // 更新统计数据
        this._updateDashboardStats();
    }
    
    /**
     * 加载任务视图
     * @private
     */
    _loadTasksView() {
        appLogger.debug('加载任务视图');
        
        // 这里可以加载任务内容
        this.pageContainer.innerHTML = `
            <div class="tasks">
                <h1>任务管理</h1>
                <div class="task-controls">
                    <button id="add-task-btn">添加任务</button>
                </div>
                <div class="task-list" id="task-list">
                    <!-- 任务列表将在这里动态生成 -->
                </div>
            </div>
        `;
        
        // 初始化任务功能
        this._initializeTasksView();
    }
    
    /**
     * 加载笔记视图
     * @private
     */
    _loadNotesView() {
        appLogger.debug('加载笔记视图');
        
        // 这里可以加载笔记内容
        this.pageContainer.innerHTML = `
            <div class="notes">
                <h1>笔记管理</h1>
                <div class="note-controls">
                    <button id="add-note-btn">添加笔记</button>
                </div>
                <div class="note-list" id="note-list">
                    <!-- 笔记列表将在这里动态生成 -->
                </div>
            </div>
        `;
        
        // 初始化笔记功能
        this._initializeNotesView();
    }
    
    /**
     * 加载设置视图
     * @private
     */
    _loadSettingsView() {
        appLogger.debug('加载设置视图');
        
        // 这里可以加载设置内容
        this.pageContainer.innerHTML = `
            <div class="settings">
                <h1>设置</h1>
                <div class="settings-form">
                    <div class="form-group">
                        <label for="theme-select">主题</label>
                        <select id="theme-select">
                            <option value="light">浅色</option>
                            <option value="dark">深色</option>
                        </select>
                    </div>
                    <div class="form-group">
                        <label for="language-select">语言</label>
                        <select id="language-select">
                            <option value="zh-CN">中文</option>
                            <option value="en-US">English</option>
                        </select>
                    </div>
                    <div class="form-group">
                        <label>
                            <input type="checkbox" id="notifications-checkbox">
                            启用通知
                        </label>
                    </div>
                    <div class="form-actions">
                        <button id="save-settings-btn">保存设置</button>
                    </div>
                </div>
            </div>
        `;
        
        // 初始化设置功能
        this._initializeSettingsView();
    }
    
    /**
     * 加载404视图
     * @private
     */
    _loadNotFoundView() {
        appLogger.debug('加载404视图');
        
        this.pageContainer.innerHTML = `
            <div class="not-found">
                <h1>页面未找到</h1>
                <p>您访问的页面不存在</p>
                <button id="back-to-dashboard-btn">返回仪表板</button>
            </div>
        `;
        
        // 添加返回按钮事件
        document.getElementById('back-to-dashboard-btn').addEventListener('click', () => {
            this.navigateToView('dashboard');
        });
    }
    
    /**
     * 初始化任务视图
     * @private
     */
    _initializeTasksView() {
        // 添加任务按钮事件
        document.getElementById('add-task-btn').addEventListener('click', () => {
            this._showAddTaskDialog();
        });
        
        // 加载任务列表
        this._loadTaskList();
    }
    
    /**
     * 初始化笔记视图
     * @private
     */
    _initializeNotesView() {
        // 添加笔记按钮事件
        document.getElementById('add-note-btn').addEventListener('click', () => {
            this._showAddNoteDialog();
        });
        
        // 加载笔记列表
        this._loadNoteList();
    }
    
    /**
     * 初始化设置视图
     * @private
     */
    _initializeSettingsView() {
        // 加载当前设置
        this._loadCurrentSettings();
        
        // 保存设置按钮事件
        document.getElementById('save-settings-btn').addEventListener('click', () => {
            this._saveSettings();
        });
    }
    
    /**
     * 加载任务列表
     * @private
     */
    _loadTaskList() {
        try {
            const tasks = JSON.parse(localStorage.getItem('tasks') || '[]');
            const taskList = document.getElementById('task-list');
            
            if (!taskList) return;
            
            taskList.innerHTML = '';
            
            if (tasks.length === 0) {
                taskList.innerHTML = '<p class="empty-message">暂无任务</p>';
                return;
            }
            
            tasks.forEach(task => {
                const taskItem = document.createElement('div');
                taskItem.className = 'task-item';
                taskItem.innerHTML = `
                    <div class="task-content">
                        <input type="checkbox" class="task-checkbox" ${task.completed ? 'checked' : ''}>
                        <span class="task-text ${task.completed ? 'completed' : ''}">${task.text}</span>
                    </div>
                    <div class="task-actions">
                        <button class="edit-task-btn" data-id="${task.id}">编辑</button>
                        <button class="delete-task-btn" data-id="${task.id}">删除</button>
                    </div>
                `;
                
                taskList.appendChild(taskItem);
            });
            
            // 添加任务事件监听器
            this._addTaskEventListeners();
        } catch (error) {
            appLogger.error('加载任务列表失败:', error);
        }
    }
    
    /**
     * 加载笔记列表
     * @private
     */
    _loadNoteList() {
        try {
            const notes = JSON.parse(localStorage.getItem('notes') || '[]');
            const noteList = document.getElementById('note-list');
            
            if (!noteList) return;
            
            noteList.innerHTML = '';
            
            if (notes.length === 0) {
                noteList.innerHTML = '<p class="empty-message">暂无笔记</p>';
                return;
            }
            
            notes.forEach(note => {
                const noteItem = document.createElement('div');
                noteItem.className = 'note-item';
                noteItem.innerHTML = `
                    <div class="note-content">
                        <h3 class="note-title">${note.title}</h3>
                        <p class="note-preview">${note.content.substring(0, 100)}...</p>
                    </div>
                    <div class="note-actions">
                        <button class="view-note-btn" data-id="${note.id}">查看</button>
                        <button class="edit-note-btn" data-id="${note.id}">编辑</button>
                        <button class="delete-note-btn" data-id="${note.id}">删除</button>
                    </div>
                `;
                
                noteList.appendChild(noteItem);
            });
            
            // 添加笔记事件监听器
            this._addNoteEventListeners();
        } catch (error) {
            appLogger.error('加载笔记列表失败:', error);
        }
    }
    
    /**
     * 加载当前设置
     * @private
     */
    _loadCurrentSettings() {
        try {
            const settings = JSON.parse(localStorage.getItem('settings') || '{}');
            
            // 设置主题
            if (settings.theme) {
                document.getElementById('theme-select').value = settings.theme;
            }
            
            // 设置语言
            if (settings.language) {
                document.getElementById('language-select').value = settings.language;
            }
            
            // 设置通知
            if (settings.notifications !== undefined) {
                document.getElementById('notifications-checkbox').checked = settings.notifications;
            }
        } catch (error) {
            appLogger.error('加载设置失败:', error);
        }
    }
    
    /**
     * 添加任务事件监听器
     * @private
     */
    _addTaskEventListeners() {
        // 任务复选框事件
        document.querySelectorAll('.task-checkbox').forEach(checkbox => {
            checkbox.addEventListener('change', (e) => {
                const taskItem = e.target.closest('.task-item');
                const taskId = taskItem.querySelector('.edit-task-btn').getAttribute('data-id');
                this._toggleTask(taskId, e.target.checked);
            });
        });
        
        // 编辑任务按钮事件
        document.querySelectorAll('.edit-task-btn').forEach(button => {
            button.addEventListener('click', (e) => {
                const taskId = e.target.getAttribute('data-id');
                this._showEditTaskDialog(taskId);
            });
        });
        
        // 删除任务按钮事件
        document.querySelectorAll('.delete-task-btn').forEach(button => {
            button.addEventListener('click', (e) => {
                const taskId = e.target.getAttribute('data-id');
                this._deleteTask(taskId);
            });
        });
    }
    
    /**
     * 添加笔记事件监听器
     * @private
     */
    _addNoteEventListeners() {
        // 查看笔记按钮事件
        document.querySelectorAll('.view-note-btn').forEach(button => {
            button.addEventListener('click', (e) => {
                const noteId = e.target.getAttribute('data-id');
                this._viewNote(noteId);
            });
        });
        
        // 编辑笔记按钮事件
        document.querySelectorAll('.edit-note-btn').forEach(button => {
            button.addEventListener('click', (e) => {
                const noteId = e.target.getAttribute('data-id');
                this._showEditNoteDialog(noteId);
            });
        });
        
        // 删除笔记按钮事件
        document.querySelectorAll('.delete-note-btn').forEach(button => {
            button.addEventListener('click', (e) => {
                const noteId = e.target.getAttribute('data-id');
                this._deleteNote(noteId);
            });
        });
    }
    
    /**
     * 切换任务完成状态
     * @private
     * @param {string} taskId - 任务ID
     * @param {boolean} completed - 是否完成
     */
    async _toggleTask(taskId, completed) {
        try {
            const tasks = JSON.parse(localStorage.getItem('tasks') || '[]');
            const taskIndex = tasks.findIndex(task => task.id === taskId);
            
            if (taskIndex !== -1) {
                tasks[taskIndex].completed = completed;
                tasks[taskIndex].updatedAt = new Date().toISOString();
                
                localStorage.setItem('tasks', JSON.stringify(tasks));
                
                // 如果API可用，同步到服务器
                if (this.api && this.networkManager && this.networkManager.getStatus().isOnline) {
                    try {
                        await this.api.updateTask(taskId, { completed, updatedAt: tasks[taskIndex].updatedAt });
                    } catch (error) {
                        appLogger.error('任务状态同步失败:', error);
                    }
                }
                
                this._showNotification(completed ? '任务已完成' : '任务标记为未完成', 'success');
            }
        } catch (error) {
            appLogger.error('切换任务状态失败:', error);
            this._showNotification('操作失败', 'error');
        }
    }
    
    /**
     * 删除任务
     * @private
     * @param {string} taskId - 任务ID
     */
    async _deleteTask(taskId) {
        if (!confirm('确定要删除这个任务吗？')) {
            return;
        }
        
        try {
            const tasks = JSON.parse(localStorage.getItem('tasks') || '[]');
            const filteredTasks = tasks.filter(task => task.id !== taskId);
            
            localStorage.setItem('tasks', JSON.stringify(filteredTasks));
            
            // 如果API可用，同步到服务器
            if (this.api && this.networkManager && this.networkManager.getStatus().isOnline) {
                try {
                    await this.api.deleteTask(taskId);
                } catch (error) {
                    appLogger.error('任务删除同步失败:', error);
                }
            }
            
            this._showNotification('任务已删除', 'success');
            this._loadTaskList(); // 重新加载任务列表
        } catch (error) {
            appLogger.error('删除任务失败:', error);
            this._showNotification('删除失败', 'error');
        }
    }
    
    /**
     * 删除笔记
     * @private
     * @param {string} noteId - 笔记ID
     */
    async _deleteNote(noteId) {
        if (!confirm('确定要删除这个笔记吗？')) {
            return;
        }
        
        try {
            const notes = JSON.parse(localStorage.getItem('notes') || '[]');
            const filteredNotes = notes.filter(note => note.id !== noteId);
            
            localStorage.setItem('notes', JSON.stringify(filteredNotes));
            
            // 如果API可用，同步到服务器
            if (this.api && this.networkManager && this.networkManager.getStatus().isOnline) {
                try {
                    await this.api.deleteNote(noteId);
                } catch (error) {
                    appLogger.error('笔记删除同步失败:', error);
                }
            }
            
            this._showNotification('笔记已删除', 'success');
            this._loadNoteList(); // 重新加载笔记列表
        } catch (error) {
            appLogger.error('删除笔记失败:', error);
            this._showNotification('删除失败', 'error');
        }
    }
    
    /**
     * 查看笔记
     * @private
     * @param {string} noteId - 笔记ID
     */
    _viewNote(noteId) {
        try {
            const notes = JSON.parse(localStorage.getItem('notes') || '[]');
            const note = notes.find(n => n.id === noteId);
            
            if (note) {
                // 这里可以显示笔记详情对话框
                alert(`标题: ${note.title}\n\n内容: ${note.content}`);
            }
        } catch (error) {
            appLogger.error('查看笔记失败:', error);
            this._showNotification('查看失败', 'error');
        }
    }
    
    /**
     * 显示添加任务对话框
     * @private
     */
    _showAddTaskDialog() {
        const taskText = prompt('请输入任务内容:');
        if (taskText && taskText.trim()) {
            this._addTask(taskText.trim());
        }
    }
    
    /**
     * 显示编辑任务对话框
     * @private
     * @param {string} taskId - 任务ID
     */
    _showEditTaskDialog(taskId) {
        try {
            const tasks = JSON.parse(localStorage.getItem('tasks') || '[]');
            const task = tasks.find(t => t.id === taskId);
            
            if (task) {
                const newText = prompt('请编辑任务内容:', task.text);
                if (newText && newText.trim() && newText !== task.text) {
                    this._updateTask(taskId, newText.trim());
                }
            }
        } catch (error) {
            appLogger.error('编辑任务失败:', error);
            this._showNotification('编辑失败', 'error');
        }
    }
    
    /**
     * 显示添加笔记对话框
     * @private
     */
    _showAddNoteDialog() {
        const title = prompt('请输入笔记标题:');
        if (title && title.trim()) {
            const content = prompt('请输入笔记内容:');
            if (content && content.trim()) {
                this._addNote(title.trim(), content.trim());
            }
        }
    }
    
    /**
     * 显示编辑笔记对话框
     * @private
     * @param {string} noteId - 笔记ID
     */
    _showEditNoteDialog(noteId) {
        try {
            const notes = JSON.parse(localStorage.getItem('notes') || '[]');
            const note = notes.find(n => n.id === noteId);
            
            if (note) {
                const newTitle = prompt('请编辑笔记标题:', note.title);
                if (newTitle && newTitle.trim()) {
                    const newContent = prompt('请编辑笔记内容:', note.content);
                    if (newContent && newContent.trim()) {
                        this._updateNote(noteId, newTitle.trim(), newContent.trim());
                    }
                }
            }
        } catch (error) {
            appLogger.error('编辑笔记失败:', error);
            this._showNotification('编辑失败', 'error');
        }
    }
    
    /**
     * 添加任务
     * @private
     * @param {string} text - 任务内容
     */
    async _addTask(text) {
        try {
            const tasks = JSON.parse(localStorage.getItem('tasks') || '[]');
            const newTask = {
                id: Date.now().toString(),
                text,
                completed: false,
                createdAt: new Date().toISOString(),
                updatedAt: new Date().toISOString()
            };
            
            tasks.push(newTask);
            localStorage.setItem('tasks', JSON.stringify(tasks));
            
            // 如果API可用，同步到服务器
            if (this.api && this.networkManager && this.networkManager.getStatus().isOnline) {
                try {
                    await this.api.addTask(newTask);
                } catch (error) {
                    appLogger.error('任务添加同步失败:', error);
                }
            }
            
            this._showNotification('任务已添加', 'success');
            this._loadTaskList(); // 重新加载任务列表
        } catch (error) {
            appLogger.error('添加任务失败:', error);
            this._showNotification('添加失败', 'error');
        }
    }
    
    /**
     * 更新任务
     * @private
     * @param {string} taskId - 任务ID
     * @param {string} text - 新任务内容
     */
    async _updateTask(taskId, text) {
        try {
            const tasks = JSON.parse(localStorage.getItem('tasks') || '[]');
            const taskIndex = tasks.findIndex(task => task.id === taskId);
            
            if (taskIndex !== -1) {
                tasks[taskIndex].text = text;
                tasks[taskIndex].updatedAt = new Date().toISOString();
                
                localStorage.setItem('tasks', JSON.stringify(tasks));
                
                // 如果API可用，同步到服务器
                if (this.api && this.networkManager && this.networkManager.getStatus().isOnline) {
                    try {
                        await this.api.updateTask(taskId, { text, updatedAt: tasks[taskIndex].updatedAt });
                    } catch (error) {
                        appLogger.error('任务更新同步失败:', error);
                    }
                }
                
                this._showNotification('任务已更新', 'success');
                this._loadTaskList(); // 重新加载任务列表
            }
        } catch (error) {
            appLogger.error('更新任务失败:', error);
            this._showNotification('更新失败', 'error');
        }
    }
    
    /**
     * 添加笔记
     * @private
     * @param {string} title - 笔记标题
     * @param {string} content - 笔记内容
     */
    async _addNote(title, content) {
        try {
            const notes = JSON.parse(localStorage.getItem('notes') || '[]');
            const newNote = {
                id: Date.now().toString(),
                title,
                content,
                createdAt: new Date().toISOString(),
                updatedAt: new Date().toISOString()
            };
            
            notes.push(newNote);
            localStorage.setItem('notes', JSON.stringify(notes));
            
            // 如果API可用，同步到服务器
            if (this.api && this.networkManager && this.networkManager.getStatus().isOnline) {
                try {
                    await this.api.addNote(newNote);
                } catch (error) {
                    appLogger.error('笔记添加同步失败:', error);
                }
            }
            
            this._showNotification('笔记已添加', 'success');
            this._loadNoteList(); // 重新加载笔记列表
        } catch (error) {
            appLogger.error('添加笔记失败:', error);
            this._showNotification('添加失败', 'error');
        }
    }
    
    /**
     * 更新笔记
     * @private
     * @param {string} noteId - 笔记ID
     * @param {string} title - 新笔记标题
     * @param {string} content - 新笔记内容
     */
    async _updateNote(noteId, title, content) {
        try {
            const notes = JSON.parse(localStorage.getItem('notes') || '[]');
            const noteIndex = notes.findIndex(note => note.id === noteId);
            
            if (noteIndex !== -1) {
                notes[noteIndex].title = title;
                notes[noteIndex].content = content;
                notes[noteIndex].updatedAt = new Date().toISOString();
                
                localStorage.setItem('notes', JSON.stringify(notes));
                
                // 如果API可用，同步到服务器
                if (this.api && this.networkManager && this.networkManager.getStatus().isOnline) {
                    try {
                        await this.api.updateNote(noteId, { title, content, updatedAt: notes[noteIndex].updatedAt });
                    } catch (error) {
                        appLogger.error('笔记更新同步失败:', error);
                    }
                }
                
                this._showNotification('笔记已更新', 'success');
                this._loadNoteList(); // 重新加载笔记列表
            }
        } catch (error) {
            appLogger.error('更新笔记失败:', error);
            this._showNotification('更新失败', 'error');
        }
    }
    
    /**
     * 保存设置
     * @private
     */
    async _saveSettings() {
        try {
            const settings = {
                theme: document.getElementById('theme-select').value,
                language: document.getElementById('language-select').value,
                notifications: document.getElementById('notifications-checkbox').checked
            };
            
            localStorage.setItem('settings', JSON.stringify(settings));
            
            // 如果API可用，同步到服务器
            if (this.api && this.networkManager && this.networkManager.getStatus().isOnline) {
                try {
                    await this.api.updateSettings(settings);
                } catch (error) {
                    appLogger.error('设置同步失败:', error);
                }
            }
            
            // 应用主题
            this._applyTheme(settings.theme);
            
            this._showNotification('设置已保存', 'success');
        } catch (error) {
            appLogger.error('保存设置失败:', error);
            this._showNotification('保存失败', 'error');
        }
    }
    
    /**
     * 应用主题
     * @private
     * @param {string} theme - 主题名称
     */
    _applyTheme(theme) {
        document.body.className = document.body.className.replace(/theme-\w+/g, '');
        document.body.classList.add(`theme-${theme}`);
    }
    
    /**
     * 添加任务
     * @param {Object} taskData - 任务数据
     * @returns {Promise<Object>} 添加的任务
     */
    async addTask(taskData) {
        try {
            appLogger.info('添加任务', taskData);
            
            // 使用API客户端添加任务
            const task = await this.api.addTask(taskData);
            
            // 更新UI
            this._addTaskToUI(task);
            
            // 显示成功提示
            this._showNotification('任务添加成功', 'success');
            
            return task;
        } catch (error) {
            appLogger.error('添加任务失败:', error);
            this._showNotification('添加任务失败: ' + error.message, 'error');
            throw error;
        }
    }
    
    /**
     * 更新任务
     * @param {string} taskId - 任务ID
     * @param {Object} updates - 更新数据
     * @returns {Promise<Object>} 更新后的任务
     */
    async updateTask(taskId, updates) {
        try {
            appLogger.info('更新任务', { taskId, updates });
            
            // 使用API客户端更新任务
            const task = await this.api.updateTask(taskId, updates);
            
            // 更新UI
            this._updateTaskInUI(task);
            
            // 显示成功提示
            this._showNotification('任务更新成功', 'success');
            
            return task;
        } catch (error) {
            appLogger.error('更新任务失败:', error);
            this._showNotification('更新任务失败: ' + error.message, 'error');
            throw error;
        }
    }
    
    /**
     * 删除任务
     * @param {string} taskId - 任务ID
     * @returns {Promise<boolean>} 是否删除成功
     */
    async deleteTask(taskId) {
        try {
            appLogger.info('删除任务', { taskId });
            
            // 使用API客户端删除任务
            const result = await this.api.deleteTask(taskId);
            
            // 更新UI
            this._removeTaskFromUI(taskId);
            
            // 显示成功提示
            this._showNotification('任务删除成功', 'success');
            
            return result;
        } catch (error) {
            appLogger.error('删除任务失败:', error);
            this._showNotification('删除任务失败: ' + error.message, 'error');
            throw error;
        }
    }
    
    /**
     * 添加笔记
     * @param {Object} noteData - 笔记数据
     * @returns {Promise<Object>} 添加的笔记
     */
    async addNote(noteData) {
        try {
            appLogger.info('添加笔记', noteData);
            
            // 使用API客户端添加笔记
            const note = await this.api.addNote(noteData);
            
            // 更新UI
            this._addNoteToUI(note);
            
            // 显示成功提示
            this._showNotification('笔记添加成功', 'success');
            
            return note;
        } catch (error) {
            appLogger.error('添加笔记失败:', error);
            this._showNotification('添加笔记失败: ' + error.message, 'error');
            throw error;
        }
    }
    
    /**
     * 更新笔记
     * @param {string} noteId - 笔记ID
     * @param {Object} updates - 更新数据
     * @returns {Promise<Object>} 更新后的笔记
     */
    async updateNote(noteId, updates) {
        try {
            appLogger.info('更新笔记', { noteId, updates });
            
            // 使用API客户端更新笔记
            const note = await this.api.updateNote(noteId, updates);
            
            // 更新UI
            this._updateNoteInUI(note);
            
            // 显示成功提示
            this._showNotification('笔记更新成功', 'success');
            
            return note;
        } catch (error) {
            appLogger.error('更新笔记失败:', error);
            this._showNotification('更新笔记失败: ' + error.message, 'error');
            throw error;
        }
    }
    
    /**
     * 删除笔记
     * @param {string} noteId - 笔记ID
     * @returns {Promise<boolean>} 是否删除成功
     */
    async deleteNote(noteId) {
        try {
            appLogger.info('删除笔记', { noteId });
            
            // 使用API客户端删除笔记
            const result = await this.api.deleteNote(noteId);
            
            // 更新UI
            this._removeNoteFromUI(noteId);
            
            // 显示成功提示
            this._showNotification('笔记删除成功', 'success');
            
            return result;
        } catch (error) {
            appLogger.error('删除笔记失败:', error);
            this._showNotification('删除笔记失败: ' + error.message, 'error');
            throw error;
        }
    }
    
    /**
     * 更新设置
     * @param {Object} settings - 设置数据
     * @returns {Promise<Object>} 更新后的设置
     */
    async updateSettings(settings) {
        try {
            appLogger.info('更新设置', settings);
            
            // 使用API客户端更新设置
            const updatedSettings = await this.api.updateSettings(settings);
            
            // 更新应用设置
            const currentSettings = JSON.parse(localStorage.getItem('settings') || '{}');
            const newSettings = { ...currentSettings, ...updatedSettings };
            localStorage.setItem('settings', JSON.stringify(newSettings));
            
            // 应用设置
            this._applySettings();
            
            // 显示成功提示
            this._showNotification('设置更新成功', 'success');
            
            return updatedSettings;
        } catch (error) {
            appLogger.error('更新设置失败:', error);
            this._showNotification('更新设置失败: ' + error.message, 'error');
            throw error;
        }
    }
    
    /**
     * 强制数据同步
     * @returns {Promise<Object>} 同步结果
     */
    async forceDataSync() {
        try {
            appLogger.info('强制数据同步');
            
            // 检查网络状态
            if (!this.networkManager || !this.networkManager.getStatus().isOnline) {
                throw new Error('网络不可用，无法同步数据');
            }
            
            // 显示同步中状态
            this._showNotification('同步中...', 'info');
            
            // 执行同步
            const result = await this.networkManager.syncOfflineChanges();
            
            // 处理同步结果
            if (result.success) {
                this._showNotification('数据同步成功', 'success');
            } else {
                this._showNotification('数据同步失败: ' + result.error, 'error');
            }
            
            return result;
        } catch (error) {
            appLogger.error('强制数据同步失败:', error);
            this._showNotification('强制数据同步失败: ' + error.message, 'error');
            throw error;
        }
    }
    
    /**
     * 强制数据迁移
     * @returns {Promise<Object>} 迁移结果
     */
    async forceDataMigration() {
        try {
            appLogger.info('强制数据迁移');
            
            if (!this.dataMigrationManager) {
                throw new Error('数据迁移管理器不可用');
            }
            
            // 显示迁移中状态
            this._showNotification('迁移中...', 'info');
            
            // 执行迁移
            const result = await this.dataMigrationManager.forceFullMigration();
            
            // 处理迁移结果
            if (result.status === 'success') {
                this._showNotification('数据迁移完成', 'success');
            } else {
                this._showNotification('数据迁移失败: ' + result.error, 'error');
            }
            
            return result;
        } catch (error) {
            appLogger.error('强制数据迁移失败:', error);
            this._showNotification('强制数据迁移失败: ' + error.message, 'error');
            throw error;
        }
    }
    
    /**
     * 获取网络状态
     * @returns {Object} 网络状态
     */
    getNetworkStatus() {
        return this.networkManager ? this.networkManager.getStatus() : { isOnline: navigator.onLine };
    }
    
    /**
     * 获取待同步操作数量
     * @returns {number} 待同步操作数量
     */
    getPendingSyncCount() {
        return this.networkManager ? this.networkManager.getOfflineOperationCount() : 0;
    }
    
    /**
     * 初始化网络管理器
     * @private
     */
    async _initNetworkManager() {
        if (this.networkManager) {
            try {
                await this.networkManager.initialize();
                appLogger.info('网络管理器初始化成功');
            } catch (error) {
                appLogger.error('网络管理器初始化失败:', error);
            }
        }
    }
    
    /**
     * 初始化数据迁移管理器
     * @private
     */
    async _initMigrationManager() {
        if (this.dataMigrationManager) {
            try {
                await this.dataMigrationManager.initialize();
                appLogger.info('数据迁移管理器初始化成功');
            } catch (error) {
                appLogger.error('数据迁移管理器初始化失败:', error);
            }
        }
    }
    
    /**
     * 更新仪表板统计
     * @private
     */
    _updateDashboardStats() {
        try {
            const tasks = JSON.parse(localStorage.getItem('tasks') || '[]');
            const notes = JSON.parse(localStorage.getItem('notes') || '[]');
            
            const taskCount = document.getElementById('task-count');
            const noteCount = document.getElementById('note-count');
            
            if (taskCount) {
                taskCount.textContent = tasks.length;
            }
            
            if (noteCount) {
                noteCount.textContent = notes.length;
            }
        } catch (error) {
            appLogger.error('更新仪表板统计失败:', error);
        }
    }
    
    /**
     * 处理窗口大小变化
     * @private
     */
    _handleResize() {
        // 这里可以添加响应式布局处理逻辑
        appLogger.debug('窗口大小已变化');
    }
    
    /**
     * 处理键盘快捷键
     * @private
     * @param {KeyboardEvent} e - 键盘事件
     */
    _handleKeyboardShortcut(e) {
        // 这里可以添加键盘快捷键处理逻辑
        if (e.ctrlKey || e.metaKey) {
            switch (e.key) {
                case 's':
                    e.preventDefault();
                    // 保存当前数据
                    break;
                case 'n':
                    e.preventDefault();
                    if (this.currentView === 'tasks') {
                        this._showAddTaskDialog();
                    } else if (this.currentView === 'notes') {
                        this._showAddNoteDialog();
                    }
                    break;
            }
        }
    }
    
    /**
     * 显示开发信息
     * @private
     */
    _showDevelopmentInfo() {
        appLogger.info('开发模式已启用');
        
        // 在开发模式下添加一些调试功能
        const debugPanel = document.createElement('div');
        debugPanel.id = 'debug-panel';
        debugPanel.className = 'debug-panel';
        debugPanel.innerHTML = `
            <h3>调试面板</h3>
            <button id="force-migration-btn">强制数据迁移</button>
            <button id="toggle-logs-btn">切换日志级别</button>
            <button id="clear-cache-btn">清除缓存</button>
        `;
        
        document.body.appendChild(debugPanel);
        
        // 添加调试功能事件
        document.getElementById('force-migration-btn').addEventListener('click', () => {
            if (this.dataMigrationManager) {
                this.dataMigrationManager.forceFullMigration().then(result => {
                    this._showNotification('强制迁移完成', 'success');
                }).catch(error => {
                    this._showNotification('强制迁移失败', 'error');
                });
            }
        });
        
        document.getElementById('toggle-logs-btn').addEventListener('click', () => {
            if (this.envConfig) {
                const currentEnv = this.envConfig.get('NODE_ENV');
                this.envConfig.switchEnvironment(currentEnv === 'development' ? 'production' : 'development');
            }
        });
        
        document.getElementById('clear-cache-btn').addEventListener('click', () => {
            localStorage.clear();
            this._showNotification('缓存已清除', 'success');
            setTimeout(() => location.reload(), 1000);
        });
    }
    
    /**
     * 显示通知
     * @private
     * @param {string} message - 通知消息
     * @param {string} type - 通知类型
     * @param {number} duration - 显示时长
     */
    _showNotification(message, type = 'info', duration = 3000) {
        const notificationContainer = document.getElementById('notification-container');
        if (!notificationContainer) return;
        
        const notification = document.createElement('div');
        notification.className = `notification notification-${type}`;
        notification.textContent = message;
        
        notificationContainer.appendChild(notification);
        
        // 自动移除通知
        setTimeout(() => {
            notification.remove();
        }, duration);
    }
    
    /**
     * 显示错误信息
     * @private
     * @param {string} message - 错误消息
     */
    _showError(message) {
        this._showNotification(message, 'error', 5000);
    }
    
    /**
     * 显示加载指示器
     * @private
     */
    _showLoadingIndicator() {
        const loadingIndicator = document.getElementById('loading-indicator');
        if (loadingIndicator) {
            loadingIndicator.style.display = 'flex';
        }
    }
    
    /**
     * 隐藏加载指示器
     * @private
     */
    _hideLoadingIndicator() {
        const loadingIndicator = document.getElementById('loading-indicator');
        if (loadingIndicator) {
            loadingIndicator.style.display = 'none';
        }
    }
}

// 创建全局应用实例
const app = new App();

// 当DOM加载完成后初始化应用
document.addEventListener('DOMContentLoaded', () => {
    app.initialize().catch(error => {
        console.error('应用初始化失败:', error);
    });
});

// 导出应用实例
if (typeof module !== 'undefined' && module.exports) {
    module.exports = { app, App };
} else {
    window.app = app;
    window.App = App;
}